package week2.Chapter3.Chapter4;

import java.util.*;
import java.io.*;

/**
 * Maze represents a maze of characters. The goal is to get from the
 * top left corner to the bottom right, following a path of l's.n Arbitrary
 * constants are used to represent locations in the maze that have been TRIED
 * and that are part of the solution PATH.
 *
 *@author Lewis and Chase
 *@version 4.0
 */
public class Maze {
    private static final int TRIED = 2;
    private static final int PATH = 3;

    private int numberRows,numberColumns;
    private int[][] grid;

    /**
     * Constructor for the Maze class. Loads a maze from the given file.
     * Throws a FileNotFoundException if the given file is not found.
     *
     * @param filename the name of the file to load
     * @throws FileNotFoundException if the given file is not found.
     */
    public Maze (String filename) throws FileNotFoundException {
        Scanner scan = new Scanner(new File(filename) );
        numberRows =scan.nextInt();
        numberColumns =scan.nextInt();

        grid =new int[numberRows][numberColumns];
        for(int i=0;i<numberRows;i++) {
            for (int j = 0; j<numberColumns ; j++) {
                grid [i][j]=scan.nextInt() ;
            }
        }
    }

    /**
     * Marks the specified position in the maze as TRTED
     *
     * @param row the index of the row to try
     * @param col the index of the column to try
     */
    public void tryPosition(int row,int col){
        grid[row][col] =TRIED ;

    }

    /**
     * Return the number of rows in this maze
     *
     * @return the number of rows in this maze
     */
    public int getRows(){
        return grid.length;
    }

    /**
     * Return the number of columns in this maze
     *
     * @return the number of columns in this maze
     */
    public int getColumns(){
        return grid[0].length;
    }

    /**
     * Marks a given position in the maze as part of the PATH
     * @param row the index of the row to mark as part of the PATH
     * @param col the index of the column to mark as part of the PATH
     */
    public void markPath(int row,int col){
        grid[row][col] = PATH;
    }

    /**
     * Determines if a specific location is valid.A valid location
     * is one that is on the grid, is not blocked, and has not been TRIED.
     *
     * @param row the row to be checked
     * @param column the column to be checked
     * @return ture if the location is valid
     */
    public boolean validPosition(int row,int column){
        boolean result = false;
        //check if cell is in the bounds of the matrix
        if (row >=0 && row <grid .length  && column>= 0 && column<grid[row].length)
        //check if cell is not blocked and not previously tried
        {
            if (grid[row][column] == 1) {
                result =true;
            }
        }
        return result;
    }

    /**
     * Return the maze as a string
     *
     * @return a string representation of the maze
     */
    @Override
    public String toString(){
        String result ="\n";
        for(int row=0;row<grid.length;row ++){
            for (int column=0;column<grid[row].length;column++) {
                result +=grid[row][column]+"";
            }
            result +="\n";
        }
        return result;
    }
}
